package com.niit.scala

import scala.collection.mutable.{ArrayBuffer, ListBuffer}

/**
 * Date:2025/3/21
 * Author：Ys
 * Description:
 */
object Base07 {


  def main(args: Array[String]): Unit = {

    /*

       1.数组
           1.1.定长数组
           1.2变长数组
           1.3数组的修改
           1.4数组的遍历
     */
    //定长数组：长度不允许改变  var/val 变量名 = new Array[数据类型](长度)
    var arr1 = new Array[Int](10) //定义一个长度为10的数组，类型为Int  默认值 0
    var arr2 = Array(10, 20, 30, 40, 50)//定义一个长度为5的数组，类型为Int，元素为10,20,30,40,50
    println( arr2( 2 ) )//输出arr2中的第三个元素
    println( arr1( 9 ) )  // 0  最大索引值 = 长度 - 1
    println(arr1.length)  // 获取数组的长度
    //println( arr1(10) )  // ArrayIndexOutOfBoundsException 数组越界 索引值从0开始   最大索引值 = 长度 - 1

    //变长数组：长度可以改变  var/val 变量名 = ArrayBuffer[数据类型]()

    var ab1 = ArrayBuffer[Int]()
    var ab2 = ArrayBuffer("Java","JavaScript","Python","Scala","C","MySQL","Hadoop","HBase","HTML-CSS")

    //数组的修改 增 删
      //添加数据
    ab2 += "Spark"
    println(ab2.length,ab2.size,ab2)
      //添加多个数据
    ab2 ++= Array("Kafka","Flume")
    println(ab2.length,ab2)
     //删除单个数据
    ab2 -= "HTML-CSS"
    println(ab2)
    ab2 --= Array("C","Python")
    println(ab2)
    ab2(1) = "PHP" //修改 根据索引值修改
    println(ab2)

    //数组的遍历
     //方式一
    for(i <- 0 to ab2.length-1){  //to: 闭区间
      println(ab2(i))
    }
    //方式二
    for(i <- 0 until ab2.length){  //until: 左闭右开的区间
      println(ab2(i))
    }

    //方式三
    for(i <- ab2){// i 就是数组中每一个元素，可以直接输出i
      println(i)
    }

    /*
    元组：元组一般用来存储不能类型的数据，并且长度和元素都不可变
    1.元组的定义
    2.访问元组中的元素
     */
    //元组的定义
    var tuple1 = ("张三",23,'男') // 常用
    var tuple2 = "李四" -> 23-> '女'//不常用
    println(tuple1,tuple2)

    //访问元组中的元素 用的不再是索引值了 而是序号
    println(tuple1._1)
    //遍历元素，前提 先用元组生成一个迭代器对象 才可以遍历
    val iterator: Iterator[Any] = tuple1.productIterator
    for (i <- iterator){
      println(i)
    }


    /*
    列表： 特点 有序 可重复
     1.不可变列表
     2.可变列表
     3.列表的扁平化
     4.列表的拉链与拉开
     5.列表的交并差集
     */
    //1.不可变列表  元素和长度是不可以改变的
    var list1 = List(3,4,1,4,2,3)//创建一个不可变的列表，元素为3,4,1,4,2,3
    var list2 = Nil //创建一个不可变的空列表
    var list3 = 2 :: -1 :: Nil //创建一个不可变的列表，元素为2,-1
    println(list1,list2,list3)
    //2.可变列表
    var lb1 = ListBuffer[Int]()
    var lb2 =ListBuffer(1,2,3,4,5)
    lb1 += 10
    lb1 += 30
    lb1 ++= List(10,3,100)
    println(lb1)
    //可变列表 转换为 不可变列表
    var list4:List[Int] = lb1.toList
    //转换为数组ss
    val arr3: Array[Int] = lb1.toArray
    // 去重 distinct
    val distinct: ListBuffer[Int] = lb1.distinct
    println(distinct)
    //获取列表中的首个元素 head
    val head: Int = lb1.head
    //获得列表中除首个元素外的其他元素 tail
    val tail: ListBuffer[Int] = lb1.tail
    //take: 从列表中获取前n个元素
    //drop: 删除列表中的前几个元素
    val value: ListBuffer[Int] = lb1.take(3)
    val value1: ListBuffer[Int] = lb1.drop(2)
    println(lb1,value,value1)

    //列表的扁平化，嵌套列表中的所有元素，单独提取出来，组成一个新的列表
    var list5 = List( List(1,2,3) ,List(4,5,6) , List(7,8,9))
    val list6 = list5.flatten
    println(list6)

    //列表的拉链与拉开
    //拉链： 将两个列表，组合成 元素为元组的列表
    val names = List("张三","李四","王五")
    val ages = List(23,24,25)
    val list7: List[(String, Int)] = names.zip(ages)
    println(list7)//List( (张三,23),  (李四,24),  (王五,25)  )
    //拉开： 将一个元组列表，拆分成两个列表的元组
    val tu: (List[String], List[Int]) = list7.unzip
    println(tu)


    //列表的交并差集
    var list8 = List(1,2,3,4)
    var list9 = List(3,4,5,6)

    //并集
    val value2: List[Int] = list8.union(list9)
    println(value2)

    //交集
    val value3: List[Int] = list8.intersect(list9)
    println(value3)
    //差集                    list8 差集 list9
    val value4: List[Int] = list8.diff(list9)
    println(value4)

  }


}
